home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Utilities / Programming / EnterAct 3.5 / Read Res project / Read_Res Source / Read_Res.c < prev   
Encoding:
C/C++ Source or Header  |  1994-12-22  |  12.2 KB  |  478 lines  |  [TEXT/KEEN]
  1. /* Read_Res.c - reads a specific resource from a file, and sends
  2. a formatted text version to the standard out file.
  3. Retrieves entire data fork if you specify resource type 'data', id 0.
  4. Shows hex and ascii values in a double-wide format. Note some example
  5. hAWK programs, eg $Print_MENU_Resource, illustrate analyzing the result
  6. from Read Resource - format the output, verify resource format. */
  7.  
  8. /* Copyright © 1991 the Free Software Foundation, Inc.
  9.  *         This file is free software; you can redistribute or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 1, or any later version.
  12.  *         This file is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15.  * GNU General Public License for more details.
  16.  *         You should have received a copy of the GNU General Public License
  17.  * along with GAWK; see the file "COPYING hAWK". If not, write to
  18.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  * Written for THINK C 4 on the Macintosh by Ken Earle (Dynabyte) Aug 1991.
  20.  */
  21.  
  22. #include "CodeResource.h"
  23. #include "AppCodeComm.h"
  24. #include "CodeResHelper.h"
  25. #include "CodeResFiles.h"
  26. #include <string.h>
  27.  
  28. //#if THINK_C >= 5
  29. //pascal void StringToNum(char *theString,long *theNum); 
  30. //pascal void NumToString(long theNum,char *theString);
  31. //#endif
  32.  
  33. #define LoadResID 406
  34.  
  35. short DoReadRes(void);
  36. pascal short  XferHookPick(short item, DialogPtr dlog);
  37. Boolean ResForkIsAlreadyOpen(StringPtr fName, short vRefNum);
  38. Boolean SpecifyResource(long *theTypePtr, short *theIDPtr);
  39. Boolean BadIDNumber(char *idStr);
  40. Handle ReadTheResource(StringPtr namePtr, short vref, long theType, short theID);
  41. Handle ReadDataFork(StringPtr namePtr, short vref);
  42. Handle FixUpResource(Handle rawH);
  43. void WriteCharToOutput( char theChar);
  44. void JumpOnError(void);
  45.  
  46.  
  47. /* Ask user to pick file, specify resource type and id. Print resource as hex
  48. and ascii to stdout. Return 1 (show resulting stdout) or -1 (error). */
  49. short DoReadRes()
  50.     {
  51.     Point         where;
  52.     SFReply     reply;
  53.     SFTypeList     types;
  54.     Handle         hText;
  55.     long         theType;
  56.     short            theID, ret = -1;
  57.  
  58.     /* calculate where to put dialog, so that it'll be centered */
  59.     GetDlogOrigin (getDlgID, &where);
  60.     
  61.     do
  62.         {
  63.         SFGetFile (where, (StringPtr)"", NULL, -1, types, XferHookPick, &reply);
  64.         } while (reply.good && ResForkIsAlreadyOpen((StringPtr)(reply.fName), reply.vRefNum));
  65.     /* If cancelled, forget it */
  66.     if (!reply.good)
  67.         return(-1);
  68.  
  69.     if (!SpecifyResource(&theType, &theID)) return(-1);
  70.     
  71.     /* Read in the resource and write it to stdout */
  72.     if (hText = ReadTheResource ((StringPtr)(reply.fName), reply.vRefNum,theType, theID))
  73.         {
  74.         hText = FixUpResource(hText);
  75.         if (hText)
  76.             {
  77.             if (PutToStdOut(hText))
  78.                 ret = 1;
  79.             DisposHandle(hText);
  80.             }
  81.         else
  82.             OKStopAlert("Not quite enough memory to do that, sorry.");
  83.         }
  84.     return(ret);
  85.     }
  86.  
  87. /* Change name of open button */
  88. pascal short  XferHookPick(short item, DialogPtr dlog)
  89.     {
  90.     short     theType;
  91.     Handle    theItem;
  92.     Rect    theBox;
  93.     char    pick[5];
  94.     
  95.     if (item == -1)
  96.         {
  97.         pick[0] = 4;
  98.         pick[1] = 'P';
  99.         pick[2] = 'i';
  100.         pick[3] = 'c';
  101.         pick[4] = 'k';
  102.         GetDItem (dlog, getOpen, &theType, &theItem, &theBox);
  103.         SetCTitle ((ControlHandle)theItem, (StringPtr)pick);
  104.         }
  105.     return (item);
  106.     }
  107.  
  108. /* Prelim assume that if youve seen one vref youve seen them all.
  109. Seems that PBGetFCBInfo never sets ioVRefNum, tho perhaps it
  110. pays attention to it...ioFCBVRefNumis for some reason set
  111. to the root of the disk. The awkward solution is to determine
  112. the owning directory ID of the file, and index thru open files,
  113. checking those that have the same dirID. */
  114. Boolean ResForkIsAlreadyOpen(StringPtr fName, short vRefNum)
  115.     {
  116.     
  117.     FCBPBRec    pb;
  118.     WDPBRec            theParms;
  119.     short            parentID;
  120.     char        fileName[32];
  121.     Boolean        resFAlreadyOpen = FALSE;
  122.     
  123.     theParms.ioVRefNum = vRefNum;
  124.     theParms.ioNamePtr = NULL;
  125.     theParms.ioWDIndex = 0;
  126.     theParms.ioWDProcID = 0;
  127.     if (PBGetWDInfo(&theParms, FALSE)) /* trouble of some kind */
  128.         return(TRUE);
  129.     parentID = theParms.ioWDDirID;
  130.     pb.ioCompletion = NULL;
  131.     pb.ioNamePtr = (StringPtr)fileName;
  132.     pb.ioVRefNum = vRefNum;
  133.     pb.ioRefNum = 0;
  134.     pb.ioFCBIndx = 1;
  135.     while (!PBGetFCBInfo(&pb, FALSE))
  136.         {
  137.         if ((short)(pb.ioFCBParID) == parentID)
  138.             {
  139.             if (PEqualStrs((Byte *)fileName, (Byte *)fName))
  140.                 {
  141.                 resFAlreadyOpen = TRUE;
  142.                 break;
  143.                 }
  144.             }
  145.         pb.ioVRefNum = vRefNum;
  146.         pb.ioRefNum = 0;
  147.         pb.ioFCBIndx += 1;
  148.         }
  149.     
  150.     if (resFAlreadyOpen)
  151.         {
  152.         OKStopAlert("Please avoid files that are already open.");
  153.         return(TRUE);
  154.         }
  155.     return(FALSE);
  156.     }
  157.  
  158. /* This should really have popup menus for the resource type and id. */
  159. Boolean SpecifyResource(long *theTypePtr, short *theIDPtr)
  160.     {
  161.     register DialogPtr        dPtr;
  162.     Ptr                        tempPtr;
  163.     short                        itemHit, theType, i, numTries;
  164.     Handle                    theItem;
  165.     Rect                    theBox;
  166.     char                    typeStr[10], idStr[10];
  167.     long                    idNum;
  168.  
  169.     InitCursor ();
  170.     
  171.     if (!GetAndAlignDialog(LoadResID))
  172.         return(FALSE);
  173.     dPtr = GetNewDialog (LoadResID, NULL, (WindowPtr)-1L);
  174.     numTries = 6;
  175.     FrameDialogItem(dPtr,1);
  176.     do{
  177.         --numTries;
  178.         SelIText (dPtr, 5, 0, 502);
  179.  
  180.     /* Give user a chance to change it and see if it's ok */
  181.         ModalDialog (NULL, &itemHit);
  182.         
  183.         if (itemHit == Cancel)
  184.             break;
  185.         
  186.         GetDItem (dPtr, 5, &theType, &theItem, &theBox);
  187.         GetIText (theItem, (StringPtr)typeStr);
  188.         GetDItem (dPtr, 6, &theType, &theItem, &theBox);
  189.         GetIText (theItem, (StringPtr)idStr);
  190.         StringToNum ((StringPtr)idStr, &idNum);
  191.     } while ((BadIDNumber(idStr) || typeStr[0] != 4) && numTries >= 0);
  192.  
  193.     
  194.     /* If cancelled, don't do anything */
  195.     if (itemHit == Cancel || numTries < 0)
  196.         {
  197.         DisposDialog (dPtr);
  198.         return(FALSE);
  199.         }
  200.     tempPtr = (Ptr)theTypePtr;
  201.     for (i = 0; i < 4; ++i)
  202.     *(tempPtr + i) = *(typeStr + i + 1);
  203.     
  204.     *theIDPtr = (short)idNum;
  205.     DisposDialog (dPtr);
  206.     return(TRUE);
  207.     }
  208.  
  209. /* Return TRUE if id number is BAD. 
  210. Leading white space not allowed.*/
  211. Boolean BadIDNumber(char *idStr)
  212.     {
  213.     short    i, len = idStr[0];
  214.     Boolean minusSeen = FALSE;
  215.     
  216.     if (len < 0 || len > 6) return(TRUE);
  217.     for (i = 1; i <= len; ++i)
  218.         {
  219.         if (idStr[i] == '-')
  220.             {
  221.             if ( i != 1)
  222.                 return(TRUE);
  223.             else
  224.                 minusSeen = TRUE;
  225.             }
  226.         else if (idStr[i] < '0' || idStr[i] > '9')
  227.             return(TRUE);
  228.         }
  229.     if (!minusSeen && len == 6) return(TRUE);
  230.     return(FALSE);
  231.     }
  232.  
  233. /* Get the specified resource. Due to overwhelming demand, also read in
  234. the data fork if wanted - this specified as 'data' id 0. */
  235. Handle ReadTheResource(StringPtr namePtr, short vref, long theType, short theID)
  236.     {
  237.     short     saveVol, refNum;
  238.     Handle    rsrcHandle, theHdle = NULL;
  239.     long            itemSize;
  240.     short                tempfNum;
  241.     
  242.     if (theType == 'data' && !theID) /* data fork requested */
  243.         return(ReadDataFork(namePtr, vref));
  244.     tempfNum = CurResFile();
  245.     
  246.     /* Remember default volume before changing it */
  247.     if (GetVol (NULL, &saveVol))
  248.         saveVol = 0;
  249.  
  250.     /* And set the volume.  This must be done because OpenResFile
  251.        looks only in current volume (directory).  Actually, it will
  252.        look along the Poor Man's Search Path, but this should do      */
  253.  
  254.     SetVol (NULL, vref);
  255.     SetResLoad(FALSE);
  256.     if ((refNum = OpenResFile (namePtr)) != -1)
  257.         {
  258.         SetResLoad(TRUE);
  259.         rsrcHandle = Get1Resource (theType, theID);
  260.  
  261.         if (rsrcHandle)
  262.             {
  263.             itemSize = GetHandleSize(rsrcHandle);
  264.             theHdle = NewHandle(itemSize);
  265.             if (MemError() == noErr)
  266.                 BlockMove(*rsrcHandle, *theHdle, itemSize);
  267.             else
  268.                 {
  269.                 ReleaseResource(rsrcHandle);
  270.                 CloseResFile (refNum);
  271.                 if (saveVol)
  272.                     SetVol (NULL, saveVol);
  273.                 UseResFile(tempfNum);
  274.                 
  275.                 OKStopAlert("Sorry, not enough memory to get the resource.");
  276.                 return(NULL);
  277.                 }
  278.             ReleaseResource(rsrcHandle);
  279.             }
  280.         else
  281.             OKStopAlert("Sorry, no resource with that type and ID. \
  282. Try using ResEdit to determine the correct type or number.");
  283.         CloseResFile (refNum);
  284.         }
  285.     else
  286.         {
  287.         SetResLoad(TRUE);
  288.         OKStopAlert("Sorry, couldn't open the resource fork \
  289. - maybe there isn't one?.");
  290.         }
  291.     /* Restore default volume if any */
  292.     if (saveVol)
  293.         SetVol (NULL, saveVol);
  294.     UseResFile(tempfNum);
  295.     
  296.     return(theHdle);
  297.     }
  298.  
  299. /* Read in the data fork to a handle. Note if there is
  300. nothing in the file then NULL is returned rather than an empty
  301. handle. */
  302. Handle ReadDataFork(StringPtr namePtr, short vref)
  303.     {
  304.     Handle        hText = NULL;
  305.     long        count;
  306.     short            saveVol, refNum;
  307.     Boolean        opened = FALSE;
  308.     
  309.     if (GetVol(NULL, &saveVol))
  310.         saveVol = 0;
  311.     if (FSOpen(namePtr, vref, &refNum))
  312.         goto JumpOut;
  313.     else
  314.         opened = TRUE;
  315.     if (GetEOF(refNum, &count) || count <= 0L)
  316.         goto JumpOut;
  317.     hText = NewHandle(count);
  318.     if (MemError() != noErr)
  319.         {
  320.         MemoryAlert();
  321.         goto JumpOut;
  322.         }
  323.     if (FSRead(refNum, &count, *hText))
  324.         {
  325.         DisposHandle(hText);
  326.         hText = NULL;
  327.         goto JumpOut;
  328.         }
  329. JumpOut:
  330.     if (opened)
  331.         FSClose(refNum);
  332.     if (saveVol)
  333.         SetVol(NULL, saveVol);
  334.     return(hText);
  335.     }
  336.  
  337. #include <ctype.h>
  338. #include <setjmp.h>
  339.  
  340. /* key code abbreviations - not all used here, but i thot you might like a list... */
  341. #define        ETX                '\003'        /* enter                 */
  342. #define        BS                '\b'        /* backspace            */
  343. #define        HT                '\t'        /* tab                    */
  344. #define        CR                0x0D        /* return                */
  345. #define        ESC                '\033'        /* clear                */
  346. #define        FS                '\034'        /* left arrow            */
  347. #define        GS                '\035'        /* right arrow            */
  348. #define        RS                '\036'        /* up arrow                */
  349. #define        US                '\037'        /* down arrow            */
  350. #define        COMMA            ','         /* or 0x2C */
  351. #define        BLANK            ' '         /* a space */
  352. #define        OPTBL            ' '            /* option-space */
  353. #define        COLON            ':'
  354. #define        FILLER            '.'        /* period, for nonascii char*/
  355.  
  356. #define        StdHdleInc        1024L
  357. static    long        outSize, privateTrueSize;
  358. static    Handle        outH;
  359.  
  360. /* buffer holding position of long jump */
  361. jmp_buf        LREnvBuf;
  362.  
  363. Handle FixUpResource(Handle rawH)
  364.     {
  365.     long        rawSize = GetHandleSize(rawH),
  366.                 startSize = 3*rawSize,
  367.                 rawPos = 0L;
  368.     Byte        *rawBPtr;
  369.     Ptr            rawPtr;
  370.     short            byteOff, i, numPads, numDigits;
  371.     char        rawChar, theChar, posStr[10];
  372.     Byte        rawBChar;
  373.     
  374.     MoveHHi(rawH);
  375.     HLock(rawH);
  376.     rawBPtr = (Byte *)(*rawH);
  377.     rawPtr = *rawH;
  378.     /* set up some convenient static stuff for creating new handle */
  379.     outSize = 0L;
  380.     privateTrueSize = 0L;
  381.     outH = NewHandle(startSize);
  382.     if (MemError() != noErr)
  383.         return(NULL);
  384.     privateTrueSize = startSize;
  385.     if (setjmp(LREnvBuf))
  386.         {
  387.         HUnlock(rawH);
  388.         DisposHandle(rawH);
  389.         DisposHandle(outH);
  390.         return(NULL);
  391.         }
  392.     /* output readable version of resource */
  393.     /* 16 bytes done per line; (8 hex space) 4 times, 16 ascii of same bytes. */
  394.     while (rawPos < rawSize)
  395.         {
  396.         /*WriteCharToOutput(HT); - for extra indent */
  397.         WriteCharToOutput(HT);
  398.         NumToString(rawPos, (StringPtr)posStr);
  399.         numDigits = posStr[0];
  400.         numPads = 5 - numDigits;
  401.         for (i = 0; i < numPads; ++i)
  402.             WriteCharToOutput(BLANK);
  403.         for (i = 1; i <= numDigits; ++i)
  404.             WriteCharToOutput(*(posStr + i));
  405.         WriteCharToOutput(COLON);
  406.         WriteCharToOutput(BLANK);
  407.         byteOff = 16;
  408.         if (rawPos + byteOff >= rawSize)
  409.             byteOff = rawSize - rawPos;
  410.         for (i = 0; i < byteOff; ++i)
  411.             {
  412.             if (i == 4 || i == 8 || i == 12)
  413.                 WriteCharToOutput(BLANK);
  414.             rawChar = *(rawPtr + rawPos + i);
  415.             if ((theChar = ((rawChar >>4) & 15)) <= 9)
  416.                 theChar += '0';
  417.             else
  418.                 theChar += 'A' - 10;
  419.             WriteCharToOutput(theChar);
  420.             if ((theChar = ((rawChar) & 15)) <= 9)
  421.                 theChar += '0';
  422.             else
  423.                 theChar += 'A' - 10;
  424.             WriteCharToOutput(theChar);
  425.             }
  426.         /* take care of the last short line - pad it out if necessary so that
  427.         text over on the right will still line up with the lines above.
  428.         Revision, after some anguish, pad the last line with zeroes rather
  429.         than blanks, to simplify manipulating the results with a hAWK program. */
  430.         for (; i < 16; ++i)
  431.             {
  432.             if (i == 4 || i == 8 || i == 12)
  433.                 WriteCharToOutput(BLANK);
  434.             WriteCharToOutput('0'); /* that's a zero */
  435.             WriteCharToOutput('0');
  436.             }
  437.         WriteCharToOutput(BLANK);
  438.         WriteCharToOutput(BLANK);
  439.         for (i = 0; i < byteOff; ++i)
  440.             {
  441.             rawBChar = *(rawBPtr + rawPos + i);
  442.             if (isprint(rawBChar))
  443.                 WriteCharToOutput((char)rawBChar);
  444.             else
  445.                 WriteCharToOutput(FILLER);
  446.             }
  447.             
  448.         rawPos += 16L;
  449.         WriteCharToOutput(CR);
  450.         }
  451.     
  452.     /* fix size of handle, dispose raw handle, return */
  453.     SetHandleSize(outH, outSize);
  454.     HUnlock(rawH);
  455.     DisposHandle(rawH);
  456.     return(outH);
  457.     }
  458.  
  459. void WriteCharToOutput( char theChar)
  460.     {
  461.     
  462.     if (outSize >= privateTrueSize)
  463.         {
  464.         SetHandleSize(outH, privateTrueSize + StdHdleInc);
  465.         if (MemError() != noErr)
  466.             JumpOnError();
  467.         privateTrueSize += StdHdleInc;
  468.         }
  469.     *(*outH + outSize++) = theChar;
  470.     }
  471.  
  472. void JumpOnError()
  473.     {
  474.     
  475.     longjmp(LREnvBuf, 1); /* return to save point */
  476.     }
  477.  
  478.